package com.shop.cereshop.app.service.location.impl;

import com.shop.cereshop.app.dao.location.CereCityManageMapper;
import com.shop.cereshop.app.domain.region.RegionGroupDTO;
import com.shop.cereshop.app.service.location.RegionService;
import com.shop.cereshop.app.utils.PinyinUtils;
import com.shop.cereshop.commons.domain.city.CereCityManage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service("locationRegionService")
public class RegionServiceImpl implements RegionService {

    @Autowired
    private CereCityManageMapper cityManageMapper;


    /**
     * 获取包含区级的城市列表接口
     * @return
     */
//    public List<RegionGroupDTO> buildThreeLevelData() {
//        // ---------------------- 步骤1：查询所有数据（一次性查询，避免多次数据库交互） ----------------------
//        List<CereCityManage> allCities = cityManageMapper.selectList(null);
//        if (allCities.isEmpty()) {
//            return Collections.emptyList();
//        }
//
//        // ---------------------- 步骤2：按 city_pid 分组，缓存所有父子关系 ----------------------
//        // key: 父级 city_id，value: 该父级下的所有子节点（如省级的子节点是市级，市级的子节点是区级）
//        Map<Long, List<CereCityManage>> childrenGroupByParentId = allCities.stream()
//                .collect(Collectors.groupingBy(CereCityManage::getCityPid));
//
//        // ---------------------- 步骤3：筛选省级数据（city_pid=0 的顶级节点） ----------------------
//        List<CereCityManage> provinces = childrenGroupByParentId.getOrDefault(0L, Collections.emptyList());
//
//        // ---------------------- 步骤4：按规则对省级数据分组（如字母分组） ----------------------
//        Map<String, List<CereCityManage>> groupedProvinces = groupProvincesByFirstLetter(provinces);
//
//        // ---------------------- 步骤5：组装三级嵌套结构（省→市→区） ----------------------
//        List<RegionGroupDTO> result = new ArrayList<>();
//        for (Map.Entry<String, List<CereCityManage>> groupEntry : groupedProvinces.entrySet()) {
//            RegionGroupDTO groupDTO = new RegionGroupDTO();
//            groupDTO.setGroupName(groupEntry.getKey()); // 分组名称（如“A”）
//
//            List<RegionGroupDTO.Province> provinceList = new ArrayList<>();
//            for (CereCityManage province : groupEntry.getValue()) {
//                // 5.1 组装省级数据 + 下属市级列表
//                RegionGroupDTO.Province provinceDTO = new RegionGroupDTO.Province();
//                provinceDTO.setProvinceName(province.getCityName());
//                provinceDTO.setProvinceCode(province.getCityId().toString());
//
//                // 获取该省下的市级数据（父级 city_id = 省级 city_id）
//                List<CereCityManage> cities = childrenGroupByParentId.getOrDefault(province.getCityId(), Collections.emptyList());
//                List<RegionGroupDTO.City> cityList = new ArrayList<>();
//                for (CereCityManage city : cities) {
//                    // 5.2 组装市级数据 + 下属区级列表
//                    RegionGroupDTO.City cityDTO = new RegionGroupDTO.City();
//                    cityDTO.setCityName(city.getCityName());
//                    cityDTO.setCityCode(city.getCityId().toString());
//
//                    // 获取该市下的区级数据（父级 city_id = 市级 city_id）
//                    List<CereCityManage> districts = childrenGroupByParentId.getOrDefault(city.getCityId(), Collections.emptyList());
//                    List<RegionGroupDTO.District> districtList = districts.stream()
//                            .map(district -> {
//                                RegionGroupDTO.District districtDTO = new RegionGroupDTO.District();
//                                districtDTO.setDistrictName(district.getCityName());
//                                districtDTO.setDistrictCode(district.getCityId().toString());
//                                return districtDTO;
//                            })
//                            .collect(Collectors.toList());
//                    cityDTO.setDistricts(districtList);
//
//                    cityList.add(cityDTO);
//                }
//                provinceDTO.setCities(cityList);
//                provinceList.add(provinceDTO);
//            }
//            groupDTO.setProvinces(provinceList);
//            result.add(groupDTO);
//        }
//
//        return result;
//    }


    /**
     * 获取不包含区级的城市列表接口
     * @return
     */
    public List<RegionGroupDTO> buildThreeLevelData() {
        // ---------------------- 步骤1：查询所有数据（一次性查询，避免多次数据库交互） ----------------------
        List<CereCityManage> allCities = cityManageMapper.selectList(null);
        if (allCities.isEmpty()) {
            return Collections.emptyList();
        }

        // ---------------------- 步骤2：按 city_pid 分组，缓存所有父子关系 ----------------------
        // key: 父级 city_id，value: 该父级下的所有子节点（如省级的子节点是市级）
        Map<Long, List<CereCityManage>> childrenGroupByParentId = allCities.stream()
                .collect(Collectors.groupingBy(CereCityManage::getCityPid));

        // ---------------------- 步骤3：筛选省级数据（city_pid=0 的顶级节点） ----------------------
        List<CereCityManage> provinces = childrenGroupByParentId.getOrDefault(0L, Collections.emptyList());

        // ---------------------- 步骤4：按规则对省级数据分组（如字母分组） ----------------------
        Map<String, List<CereCityManage>> groupedProvinces = groupProvincesByFirstLetter(provinces);

        // ---------------------- 步骤5：组装二级嵌套结构（省→市） ----------------------
        List<RegionGroupDTO> result = new ArrayList<>();
        for (Map.Entry<String, List<CereCityManage>> groupEntry : groupedProvinces.entrySet()) {
            RegionGroupDTO groupDTO = new RegionGroupDTO();
            groupDTO.setGroupName(groupEntry.getKey()); // 分组名称（如"A"）

            List<RegionGroupDTO.Province> provinceList = new ArrayList<>();
            for (CereCityManage province : groupEntry.getValue()) {
                // 5.1 组装省级数据 + 下属市级列表
                RegionGroupDTO.Province provinceDTO = new RegionGroupDTO.Province();
                provinceDTO.setProvinceName(province.getCityName());
                provinceDTO.setProvinceCode(province.getCityId().toString());

                // 获取该省下的市级数据（父级 city_id = 省级 city_id）
                List<CereCityManage> cities = childrenGroupByParentId.getOrDefault(province.getCityId(), Collections.emptyList());
                List<RegionGroupDTO.City> cityList = cities.stream()
                        .map(city -> {
                            RegionGroupDTO.City cityDTO = new RegionGroupDTO.City();
                            cityDTO.setCityName(city.getCityName());
                            cityDTO.setCityCode(city.getCityId().toString());
                            // 不再查询和设置区级数据
                            return cityDTO;
                        })
                        .collect(Collectors.toList());

                provinceDTO.setCities(cityList);
                provinceList.add(provinceDTO);
            }
            groupDTO.setProvinces(provinceList);
            result.add(groupDTO);
        }

        return result;
    }



    /**
     * 按省份名称首字母分组（生成 groupName，如“A”“B”）
     */
    private Map<String, List<CereCityManage>> groupProvincesByFirstLetter(List<CereCityManage> provinces) {
        Map<String, List<CereCityManage>> groupMap = new TreeMap<>(); // TreeMap 按字母顺序排序
        for (CereCityManage province : provinces) {
            String provinceName = province.getCityName();
            String firstLetter = PinyinUtils.getFirstLetter(provinceName).toUpperCase(); // 获取拼音首字母
            String groupKey = firstLetter.matches("[A-Z]") ? firstLetter : "#"; // 非字母归类到“#”
            groupMap.computeIfAbsent(groupKey, k -> new ArrayList<>()).add(province);
        }
        return groupMap;
    }
}
